﻿using System;
using System.Collections.Generic;
using Bastanteo.Dominio;
using Bastanteo.Persistencia;
using NUnit.Framework;

namespace Bastanteo.Pruebas
{
    [TestFixture]
    public class Test1_PoderDAO
    {
        IPoderDAO dao = null;
        Poder creado = null;


        [TestFixtureSetUp]
        public void InicializarPruebas()
        {
            dao = new Persistencia.NH.PoderDAO(); // Instanciamos la implementación elegida (ADO o NHibernate)
            foreach (Poder poder in dao.ListarTodos())
               dao.Eliminar(poder);
        }

        [Test]
        public void Test1_Crear()
        {
            // 1. Validar que ocurra un error al intentar crear un Poder con un dato nulo
            Poder poderACrear = new Poder();
            poderACrear.Descripcion = "Cobro de cheque";
            Assert.Catch<Exception>(delegate
            {
                creado = dao.Crear(poderACrear);
            });
            // 2. Validar que se cree un Poder correctamente (sin error)
            poderACrear.TipoProducto = "Activo";
            Assert.DoesNotThrow(delegate
            {
                creado = dao.Crear(poderACrear);
            });
            // 3. Validar que el poder creado no sea nulo, tenga un código mayor a 0 y la descripción sea la ingresada
            Assert.IsNotNull(creado);
            Assert.Greater(creado.CodigoPoder, 0);
            Assert.AreEqual(creado.Descripcion, poderACrear.Descripcion);
        }
        [Test]
        public void Test2_Obtener()
        {
            Poder poderObtenido = null;
            // 1. Validar que se retorne nulo al obtener un poder inexistente
            Assert.DoesNotThrow(delegate
            {
                poderObtenido = dao.Obtener(1000);
            });
            Assert.IsNull(poderObtenido);
            // 2. Validar que se obtenga el poder creado satisfactoriamente
            Assert.DoesNotThrow(delegate
            {
                poderObtenido = dao.Obtener(creado.CodigoPoder);
            });
            Assert.IsNotNull(poderObtenido);
            // 3. Validar que la descripcion obtenida sea la creada anteriormente
            Assert.AreEqual(poderObtenido.Descripcion, "Cobro de cheque"); //
        }
        [Test]
        public void Test3_Modificar()
        {
            Poder poderAModificar = dao.Obtener(creado.CodigoPoder);
            poderAModificar.Descripcion = null;
            Poder poderModificado = null;
            // 1. Validar que ocurrar un error al intentar modificar el Poder con un nombre nulo
            Assert.Catch<Exception>(delegate
            {
                poderModificado = dao.Modificar(poderAModificar);
            });
            // 2. Validar que se modifique correctamente el poder
            poderAModificar.Descripcion = "Retiro de efectivo";
            Assert.DoesNotThrow(delegate
            {
                poderModificado = dao.Modificar(poderAModificar);
            });
            // 3. Validar que el Poder modificado no sea nulo, tenga la razón social, número de empleados y tipo indicados
            Assert.IsNotNull(poderModificado);
            Assert.AreEqual(poderAModificar.Descripcion, poderModificado.Descripcion);
        }
        [Test]
        public void Test4_Eliminar()
        {
            Poder poderAEliminar = dao.Obtener(creado.CodigoPoder);
            // 1. Validar que ocurre un error si se intenta eliminar un Poder nulo
            Assert.Catch<Exception>(delegate
            {
                dao.Eliminar(null);
            });
            // 2. Validar que se elimina correctamente el Poder creado
            Assert.DoesNotThrow(delegate
            {
                dao.Eliminar(poderAEliminar);
            });
            // 3. Validar que luego de eliminado se retorne nulo al obtenerlo
            Poder clienteEliminado = dao.Obtener(creado.CodigoPoder);
            Assert.IsNull(clienteEliminado);

        }
        [Test]
        public void Test5_Listar()
        {
            dao.Crear(new Poder() { Descripcion = "Cobro de cheque", TipoProducto = "Activo" });
            dao.Crear(new Poder() { Descripcion = "Retiro de efectivo", TipoProducto = "Pasivo" });
            // 1. Validar que se listen los poders existentes exitosamente
            ICollection<Poder> podersExistentes = null;
            Assert.DoesNotThrow(delegate
            {
                podersExistentes = dao.ListarTodos();
            });
            // 2. Validar que se retornen al menos los 2 clientes creados previamente
            Assert.GreaterOrEqual(podersExistentes.Count, 2);
            // 3. Validar que cada Poder obtenido tenga una descripcion no nula
            foreach (Poder poder in podersExistentes)
                Assert.IsNotNull(poder.Descripcion);
        }

        [TestFixtureTearDown]
        public void FinalizarPruebas()
        {
            foreach (Poder Poder in dao.ListarTodos()) 
            dao.Eliminar(Poder);
            Persistencia.NH.NHibernateHelper.CerrarFabrica();
        }
    }
}